Przykad 8.4. Zoptymalizowana realizacja algorytmu Forda-Fulkersona
public class Optimized extends FlowNetwork {
   int[][] capacity;      // Zawiera wszystkie przepustowoci
   int[] flow;            // Zawiera wszystkie przepywy
   int[] previous;        // Zawiera wczeniejsze informacje cieki
   int[] visited;  // Odwiedzone podczas poszukiwania cieki powikszajcej

   final int QUEUE_SIZE;  // Rozmiar kolejki nigdy nie bdzie wikszy ni n
   final int queue[];     // W realizacji jest uywana kolejka cykliczna

   // Zaaduj informacje
   public Optimized (int n, int s, int t, Iterator<EdgeInfo> edges) {
      // Najpierw zainicjuj nadklas
      super(n, s, t);

      queue = new int[n];
      QUEUE_SIZE = n;
      capacity = new int[n][n];
      flow = new int[n][n];
      previous = new int[n];
      visited = new int[n];

      // Na pocztku przepyw jest ustawiony na 0. Pobierz info ze rda
      while (edges.hasNext()) {
         EdgeInfo ei = edges.next();
         capacity[ei.start][ei.end] = ei.capacity;
      }
   }

   // Oblicz i zwr przepyw maksymalny
   public int compute (int source, int sink) {
      int maxFlow = 0;
      while (search(source, sink)) { maxFlow += processPath(source, sink); }
      return maxFlow;
   }

   // Powiksz przepyw wewntrz sieci wzdu znalezionej cieki od
   // rda do ujcia
    protected void processPath(int source, int sink) {
      // Okrel, o ile zwikszy przepyw. Rwnaj do minimum
      // ze cieki obliczonej od ujcia do rda
      int increment = Integer.MAX_VALUE;
      int v = sink;
      while (previous[v] != -1) {
         int (unit = capacity[previous[v]][v])  flow[previous[v]][v];
         if (unit < increment) { increment = unit; }
         v = previous[v];
      }

      // Od minimalny przyrost na ciece
      v = sink;
      while (previous[v] != -1) {
         flow[previous[v]][v]) += increment;  // krawdzie przednie;
         flow[v][previous[v]]] -= increment;  // nie zapomnij o krawdziach
         v = previous[v];                     // tylnych
      }

      return increment;
   }

   // Znajd w sieci przepywowej ciek powikszajc od rda do ujcia
   public boolean search (int source, int sink) {
      // Wyczy stan odwiedzin. 0=czysty, 1=aktywny w kolejce, 2=odwiedzony
      for (int i = 0; i < numVertices; i++) { visited[i] = 0; }

      // Utwrz kolejk cykliczn do przetwarzania elementw poszukiwania
      queue[0] = source;
      int head = 0, tail = 1;
      previous[source] = -1;    // Aby mie pewno, e tutaj koczymy;
      visited[source] = 1;      // aktywnie w kolejce
      while (head != tail) {
         int u = queue[head]; head = (head + 1) % QUEUE_SIZE;
         visited[u] = 2;

         // Dodaj do kolejki nie odwiedzone, ssiednie wierzchoki u
         // z wystarczajc przepustowoci
         for (int v = 0; v < numVertices; v++) {
            if (visited[v] == 0 && capacity[u][v] > flow[u][v]) {
               queue[tail] = v;  tail = (tail + 1) % QUEUE_SIZE;
               visited[v] = 1;  // aktywnie w kolejce  
               previous[v] = u;
            }
         }
      }

      return visited[sink] != 0;   // Czy dotarlimy do ujcia?
   }
}
